geometry 3 → 4

data/lib/geometry/rotation.rb

@@ -0,0 +1,46 @@
+module Geometry
+=begin
+A generalized representation of a rotation transformation.
+=end
+    class Rotation
+	# !@attribute [r] dimensions
+	# @return [Integer]
+	attr_reader :dimensions
+	attr_reader :x, :y, :z
+
+	# @overload initialize(options={})
+	# @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 < @dimensions)) ? Array.new(@dimensions) {|i| a[i] || 0 } : a }
+		end
+	    end
+	end
+
+	def identity?
+	    (!@x && !@y && !@z) || ([@x, @y, @z].select {|a| a}.all? {|a| a.respond_to?(:magnitude) ? (1 == a.magnitude) : (1 == a.size)})
+	end
+    end
+end

data/lib/geometry/size_zero.rb

@@ -0,0 +1,69 @@
+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.
+=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
+

data/lib/geometry/square.rb

@@ -0,0 +1,103 @@
+require_relative 'point'
+
+module Geometry
+    NotSquareError = Class.new(ArgumentError)
+
+=begin
+The {Square} class cluster is like the {Rectangle} class cluster, but not longer in one direction.
+
+== Constructors
+
+    square = Square.new [1,2], [2,3]	# Using two corners
+    square = Square.new [3,4], 5	# Using an origin point and a size
+    square = Square.new 6		# Using a size and an origin of [0,0]
+=end
+    class Square
+	attr_reader :origin
+
+	# Creates a {Square} given two {Point}s
+	# @param [Point] point0	A corner (ie. bottom-left)
+	# @param [Point] point1	The other corner (ie. top-right)
+	def initialize(point0, point1)
+	    point0, point1 = Point[point0], Point[point1]
+	    raise(ArgumentError, "Point sizes must match (#{point0.size} != #{point1.size}") unless point0.size == point1.size
+
+	    # Reorder the points to get lower-left and upper-right
+	    minx, maxx = [point0.x, point1.x].minmax
+	    miny, maxy = [point0.y, point1.y].minmax
+	    @points = [Point[minx, miny], Point[maxx, maxy]]
+
+	    raise(NotSquareError) if height != width
+	end
+
+# !@group Accessors
+	# !@attribute [r] origin
+	# @return [Point] The lower left corner
+	def origin
+	    @points.first
+	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
+
+    # A {Square} created with a center point and a size
+    class CenteredSquare < Square
+	# !@attribute [r] center
+	# @return [Point]   The center of the {Square}
+	attr_reader :center
+
+	# @param [Point]	center	The center point
+	# @param [Numeric]	size	The length of each side
+	def initialize(center, size)
+	    @center = Point[center]
+	    @size = size
+	end
+
+# !@group Accessors
+	# !@attribute [r] origin
+	# @return [Point] The lower left corner
+	def origin
+	    Point[@center.x - size/2, @center.y - size/2]
+	end
+
+	# !@attribute [r] points
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
+	def points
+	    half_size = @size/2
+	    minx = @center.x - half_size
+	    maxx = @center.x + half_size
+	    miny = @center.y - half_size
+	    maxy = @center.y + half_size
+
+	    [Point[minx,miny], Point[minx,maxy], Point[maxx, maxy], Point[maxx, miny]]
+	end
+
+	def height
+	    @size
+	end
+
+	def width
+	    @size
+	end
+# !@endgroup
+    end
+
+    # A {Square} created with an origin point and a size
+    class SizedSquare < Square
+	# @param [Point]    origin  The origin point (bottom-left corner)
+	# @param [Numeric]  size    The length of each side
+	def initialize(origin, size)
+	    @origin = Point[origin]
+	    @size = size
+	end
+    end
+end

data/lib/geometry/transformation.rb

@@ -0,0 +1,106 @@
+require 'geometry/point'
+require 'geometry/rotation'
+
+module Geometry
+=begin
+{Transformation} represents a relationship between two coordinate frames
+
+To create a pure translation relationship:
+
+    translate = Geometry::Transformation.new(:translate => Point[4, 2])
+
+To create a transformation with an origin and an X-axis aligned with the parent
+coordinate system's Y-axis (the Y and Z axes will be chosen arbitrarily):
+
+    translate = Geometry::Transformation.new(:origin => [4, 2], :x => [0,1,0])
+
+To create a transformation with an origin, an X-axis aligned with the parent
+coordinate system's Y-axis, and a Y-axis aligned with the parent coordinate
+system's X-axis:
+
+    translate = Geometry::Transformation.new(:origin => [4, 2], :x => [0,1,0], :y => [1,0,0])
+=end
+    class Transformation
+	attr_reader :dimensions
+    	attr_reader :rotation
+    	attr_reader :scale
+    	attr_reader :translation
+
+	attr_reader :x_axis, :y_axis, :z_axis
+
+    	# @overload new(translate, rotate, scale)
+    	# @param [Point] translate	Linear displacement
+    	# @param [Rotation] rotate	Rotation
+    	# @param [Vector]   scale	Scaling
+    	# @overload new(options)
+    	# @param [Hash] options
+	# @option options [Integer]	:dimensions Dimensionality of the transformation
+    	# @option options [Point]	:origin	    Same as :translate
+    	# @option options [Point]	:move	    Same as :translate
+    	# @option options [Point]	:translate  Linear displacement
+    	# @option options [Rotation]	:rotate	    Rotation
+    	# @option options [Vector]	:scale	    Scaling
+	# @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}
+	    translate, rotate, scale = args
+	    options = options.reduce({}, :merge)
+
+	    @dimensions = options[:dimensions] || nil
+
+	    @rotation = options[:rotate] || rotate || Geometry::Rotation.new(options)
+	    @scale = options[:scale] || scale
+
+	    case options.count {|k,v| [:move, :origin, :translate].include? k }
+		when 0
+		    @translation = translate
+		when 1
+		    @translation = (options[:translate] ||= options.delete(:move) || options.delete(:origin))
+		else
+		    raise ArgumentError, "Too many translation parameters in #{options}"
+	    end
+
+	    @translation = Point[*@translation]
+	    if @translation
+		@translation = nil if @translation.all? {|v| v == 0}
+		raise ArgumentError, ":translate must be a Point or a Vector" if @translation and not @translation.is_a?(Vector)
+	    end
+
+	    if @dimensions
+		biggest = [@translation, @scale].select {|a| a}.map {|a| a.size}.max
+
+		if biggest and (biggest != 0) and (((biggest != @dimensions)) or (@rotation and (@rotation.dimensions != biggest)))
+		    raise ArgumentError, "Dimensionality mismatch"
+		end
+	    end
+	end
+
+	# Returns true if the {Transformation} is the identity transformation
+	def identity?
+	    @rotation.identity? && !(@scale || @translation)
+	end
+
+	# 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
+	    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
+	    end
+	end
+    end
+end

data/lib/geometry/vector.rb

@@ -0,0 +1,14 @@
+require 'matrix'
+
+# Monkeypatch Vector to overcome some deficiencies
+class Vector
+# !@group Unary operators
+    def +@
+	self
+    end
+
+    def -@
+	Vector[*(@elements.map {|e| -e })]
+    end
+# !@endgroup
+end

data/test/{test_geometry.rb → geometry.rb}

@@ -1,12 +1,13 @@
-require_relative 'helper'
-require_relative '../lib/geometry'
+require 'minitest/autorun'
+require 'geometry'
 
-class GeometryTest < Test::Unit::TestCase
-    must "create a Point object" do
+describe Geometry do
+    it "create a Point object" do
 	point = Geometry.point(2,1)
 	assert_kind_of(Geometry::Point, point)
     end
-    must "create a Line object" do
+
+    it "create a Line object" do
 	line = Geometry.line([0,0], [10,10])
 	assert_kind_of(Geometry::Line, line)
 	assert_kind_of(Geometry::TwoPointLine, line)

data/test/geometry/arc.rb

@@ -0,0 +1,13 @@
+require 'minitest/autorun'
+require 'geometry/arc'
+
+describe Geometry::Arc do
+    it "must create an Arc object from a Point and a radius" do
+	arc = Geometry::Arc.new [1,2], 3, 0, 90
+	arc.must_be_kind_of Geometry::Arc
+	arc.center.must_equal Point[1,2]
+	arc.radius.must_equal 3
+	arc.start_angle.must_equal 0
+	arc.end_angle.must_equal 90
+    end
+end

data/test/geometry/circle.rb

@@ -1,22 +1,22 @@
-require_relative '../helper'
-require_relative '../../lib/geometry/circle'
+require 'minitest/autorun'
+require 'geometry/circle'
 
 def Circle(*args)
     Geometry::Circle.new(*args)
 end
 
-class CircleTest < Test::Unit::TestCase
-    must "create a Circle object from a Point and a radius" do
+describe Geometry::Circle do
+    it "must create a Circle object from a Point and a radius" do
 	circle = Circle [1,2], 3
 	assert_kind_of(Geometry::Circle, circle)
     end
 
-    must "have a center point accessor" do
+    it "must have a center point accessor" do
 	circle = Circle [1,2], 3
 	assert_equal(circle.center, [1,2])
     end
 
-    must "have a radius accessor" do
+    it "must have a radius accessor" do
 	circle = Circle [1,2], 3
 	assert_equal(3, circle.radius)
     end

data/test/geometry/edge.rb

@@ -1,40 +1,40 @@
-require_relative '../helper'
-require_relative '../../lib/geometry/edge'
+require 'minitest/autorun'
+require 'geometry/edge'
 
 def Edge(*args)
     Geometry::Edge.new(*args)
 end
 
-class EdgeTest < Test::Unit::TestCase
+describe Geometry::Edge do
     Edge = Geometry::Edge
 
-    must "create an Edge object" do
-	edge = Geometry::Edge.new([0,0], [1,0])
+    it "must create an Edge object" do
+	edge = Edge.new([0,0], [1,0])
 	assert_kind_of(Geometry::Edge, edge)
 	assert_equal(Geometry::Point[0,0], edge.first)
 	assert_equal(Geometry::Point[1,0], edge.last)
     end
-    must "create swap endpoints in place" do
-	edge = Geometry::Edge.new([0,0], [1,0])
-	assert_kind_of(Geometry::Edge, edge)
+    it "must create swap endpoints in place" do
+	edge = Edge.new([0,0], [1,0])
+	assert_kind_of(Edge, edge)
 	edge.reverse!
 	assert_equal(Geometry::Point[1,0], edge.first)
 	assert_equal(Geometry::Point[0,0], edge.last)
     end
-    must "handle equality" do
-	edge1 = Geometry::Edge.new([1,0], [0,1])
-	edge2 = Geometry::Edge.new([1,0], [0,1])
-	edge3 = Geometry::Edge.new([1,1], [5,5])
+    it "must handle equality" do
+	edge1 = Edge.new([1,0], [0,1])
+	edge2 = Edge.new([1,0], [0,1])
+	edge3 = Edge.new([1,1], [5,5])
 	assert_equal(edge1, edge2)
-	assert_not_equal(edge1, edge3)
+	edge1.wont_equal edge3
     end
 
-    must "return the height of the edge" do
+    it "must return the height of the edge" do
 	edge = Edge([0,0], [1,1])
 	assert_equal(1, edge.height)
     end
 
-    must "return the width of the edge" do
+    it "must return the width of the edge" do
 	edge = Edge([0,0], [1,1])
 	assert_equal(1, edge.width)
     end