geometry 6 → 6.1

data/lib/geometry/rectangle.rb

@@ -78,6 +78,8 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 		SizedRectangle.new(height: options[:height], width: options[:width])
 	    elsif (2==args.count) and (args.all? {|a| a.is_a?(Array) || a.is_a?(Point) })
 		original_new(*args)
+	    elsif options.empty?
+		raise ArgumentError, "#{self} arguments must be named, not: #{args}"
 	    else
 		raise ArgumentError, "Bad Rectangle arguments: #{args}, #{options}"
 	    end
@@ -171,6 +173,39 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    max.x - min.x
 	end
 # @endgroup
+
+	# Create a new {Rectangle} from the receiver that's inset by the given amount
+	# @overload inset(x, y)
+	# @overload inset(top, left, bottom, right)
+	# @overload inset(x, y)
+	#   @option options [Number] :x	    Inset from the left and right sides
+	#   @option options [Number] :y	    Inset from the top and bottom
+	# @overload inset(top, left, bottom, right)
+	#   @option options [Number] :bottom	The inset from the bottom of the {Rectangle}
+	#   @option options [Number] :left	The inset from the left side of the {Rectangle}
+	#   @option options [Number] :right	The inset from the right side of the {Rectangle}
+	#   @option options [Number] :top	The inset from the top of the {Rectangle}
+	def inset(*args)
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+	    raise ArumentError, "Can't specify both arguments and options" if !args.empty? && !options.empty?
+
+	    if 1 == args.size
+		distance = args.shift
+		Rectangle.new from:(min + distance), to:(max - distance)
+	    elsif 2 == args.size
+		distance = Point[*args]
+		Rectangle.new from:(min + distance), to:(max - distance)
+	    elsif 4 == args.size
+		top, left, bottom, right = *args
+		Rectangle.new from:(min + Point[left, bottom]), to:(max - Point[right, top])
+	    elsif options[:x] && options[:y]
+		distance = Point[options[:x], options[:y]]
+		Rectangle.new from:(min + distance), to:(max - distance)
+	    elsif options[:top] && options[:left] && options[:bottom] && options[:right]
+		Rectangle.new from:(min + Point[options[:left], options[:bottom]]), to:(max - Point[options[:right], options[:top]])
+	    end
+	end
     end
 
     class CenteredRectangle < Rectangle

data/lib/geometry/regular_polygon.rb

@@ -27,18 +27,18 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 	# @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	The center point of the {RegularPolygon}
+	#   @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	The center point of the {RegularPolygon}
+	#   @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] : nil
+	    center = center ? Point[center] : Point.zero
 
 	    if options.has_key?(:radius)
 		self.allocate.tap {|polygon| polygon.send :initialize, options[:sides], center, options[:radius], &block }
@@ -66,11 +66,43 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 	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
 

data/lib/geometry/rotation.rb

@@ -1,16 +1,39 @@
 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
-	# @attribute [r] dimensions
-	# @return [Integer]
+	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
@@ -53,8 +76,10 @@ A generalized representation of a rotation transformation.
 	end
 
 	# @attribute [r] matrix
-	# @return [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}
 
@@ -74,5 +99,92 @@ A generalized representation of a rotation transformation.
 
 	    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_zero.rb

@@ -5,7 +5,8 @@ module Geometry
 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.
+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)

data/lib/geometry/transformation.rb

@@ -1,9 +1,11 @@
 require 'geometry/point'
 require 'geometry/rotation'
 
+require_relative 'transformation/composition'
+
 module Geometry
 =begin
-{Transformation} represents a relationship between two coordinate frames
+{Transformation} represents a relationship between two coordinate frames.
 
 To create a pure translation relationship:
 
@@ -38,6 +40,7 @@ system's X-axis:
     	# @option options [Point]	:origin	    Same as :translate
     	# @option options [Point]	:move	    Same as :translate
     	# @option options [Point]	:translate  Linear displacement
+	# @option options [Angle]	:angle	    Rotation angle (assumes planar geometry)
     	# @option options [Rotation]	:rotate	    Rotation
     	# @option options [Vector]	:scale	    Scaling
 	# @option options [Vector]	:x	    X-axis
@@ -50,7 +53,8 @@ system's X-axis:
 
 	    @dimensions = options[:dimensions] || nil
 
-	    @rotation = options[:rotate] || rotate || Geometry::Rotation.new(options)
+	    rotation_options = options.select {|key, value| [:angle, :x, :y, :z].include? key }
+	    @rotation = options[:rotate] || rotate || ((rotation_options.size > 0) ? Geometry::Rotation.new(rotation_options) : nil)
 	    @scale = options[:scale] || scale
 
 	    case options.count {|k,v| [:move, :origin, :translate].include? k }
@@ -62,6 +66,7 @@ system's X-axis:
 		    raise ArgumentError, "Too many translation parameters in #{options}"
 	    end
 
+	    raise ArgumentError, "Bad translation" if @translation.is_a? Hash
 	    @translation = Point[*@translation]
 	    if @translation
 		@translation = nil if @translation.all? {|v| v == 0}
@@ -77,42 +82,90 @@ system's X-axis:
 	    end
 	end
 
+	def initialize_clone(source)
+	    super
+	    @rotation = @rotation.clone if @rotation
+	    @scale = @scale.clone if @scale
+	    @translation = @translation.clone if @translation
+	end
+
+	# !@attribute [r] has_rotation?
+	#   @return [Bool] true if the transformation has any rotation components
+	def has_rotation?
+	    !!@rotation
+	end
+
 	# Returns true if the {Transformation} is the identity transformation
 	def identity?
-	    @rotation.identity? && !(@scale || @translation)
+	    !(@rotation || @scale || @translation)
 	end
 
 	def eql?(other)
-	    (self.rotation.eql? other.rotation) && (self.scale.eql? other.scale) && (self.translation.eql? other.translation)
+	    return false unless other
+	    return true if !self.dimensions && !other.dimensions && !self.rotation && !other.rotation && !self.translation && !other.translation && !self.scale && !other.scale
+	    return false if !(self.dimensions && other.dimensions) && !(self.rotation && other.rotation) && !(self.translation && other.translation) && !(self.scale && other.scale)
+
+	    ((self.dimensions && other.dimensions && self.dimensions.eql?(other.dimensions)) || !(self.dimensions && other.dimensions)) &&
+	    ((self.rotation && other.rotation && self.rotation.eql?(other.rotation)) || !(self.rotation && other.rotation)) &&
+	    ((self.scale && other.scale && self.scale.eql?(other.scale)) || !(self.scale && other.rotation)) &&
+	    ((self.translation && other.translation && self.translation.eql?(other.translation)) || !(self.scale && other.rotation))
 	end
 	alias :== :eql?
 
 	# Compose the current {Transformation} with another one
 	def +(other)
-	    if other.is_a?(Array) or other.is_a?(Vector)
-		if @translation
-		    Transformation.new(@translation+other, @rotation, @scale)
-		else
-		    Transformation.new(other, @rotation, @scale)
-		end
+	    return self.clone unless other
+
+	    case other
+		when Array, Vector
+		    if @translation
+			Transformation.new(@translation+other, @rotation, @scale)
+		    else
+			Transformation.new(other, @rotation, @scale)
+		    end
+		when Composition
+		    Composition.new(self, *other.transformations)
+		when Transformation
+		    if @rotation || other.rotation
+			Composition.new(self, other)
+		    else
+			translation = @translation ? (@translation + other.translation) : other.translation
+			Transformation.new(translation, @rotation, @scale)
+		    end
 	    end
 	end
 
 	def -(other)
-	    if other.is_a?(Array) or other.is_a?(Vector)
-		if @translation
-		    Transformation.new(@translation-other, @rotation, @scale)
-		else
-		    Transformation.new(other.map {|e| -e}, @rotation, @scale)
-		end
+	    return self.clone unless other
+
+	    case other
+		when Array, Vector
+		    if @translation
+			Transformation.new(@translation-other, @rotation, @scale)
+		    else
+			Transformation.new(other.map {|e| -e}, @rotation, @scale)
+		    end
+		when Transformation
+		    if @rotation
+			rotation = other.rotation ? (@rotation - other.rotation) : @rotation
+		    elsif other.rotation
+			rotation = -other.rotation
+		    else
+			rotation = nil
+		    end
+
+		    translation = @translation ? (@translation - other.translation) : -other.translation
+
+		    Transformation.new(translation, rotation, @scale)
 	    end
 	end
 
-	# Transform and return a new {Point}
-	# @param [Point] point	The {Point} to transform
+	# Transform and return a new {Point}. Rotation is applied before translation.
+	# @param [Point] point	the {Point} to transform into the parent coordinate frame
 	# @return [Point]   The transformed {Point}
 	def transform(point)
-	    @translation + point
+	    point = @rotation.transform(point) if @rotation
+	    @translation ? (@translation + point) : point
 	end
     end
 end

data/lib/geometry/transformation/composition.rb

@@ -0,0 +1,39 @@
+module Geometry
+    class Transformation
+	class Composition
+	    attr_reader :transformations
+
+	    def initialize(*args)
+		raise TypeError unless args.all? {|a| a.is_a? Transformation }
+		@transformations = *args
+	    end
+
+	    def +(other)
+		case other
+		    when Transformation
+			Composition.new(*transformations, other)
+		    when Composition
+			Composition.new(*transformations, *other.transformations)
+		end
+	    end
+
+# @group Accessors
+	    # !@attribute [r] has_rotation?
+	    #   @return [Bool] true if the transformation has any rotation components
+	    def has_rotation?
+		transformations.any? {|t| t.is_a?(Rotation) || t.has_rotation? }
+	    end
+
+	    # !@attribute [r] size
+	    #   @return [Number] the number of composed {Transformation}s
+	    def size
+		transformations.size
+	    end
+# @endgroup
+
+	    def transform(point)
+		transformations.reverse.reduce(point) {|point, transformation| transformation.transform(point) }
+	    end
+	end
+    end
+end