geometry-in-ruby 0.0.1

data/lib/geometry/transformation.rb

@@ -0,0 +1,171 @@
+require 'geometry/point'
+require 'geometry/rotation'
+
+require_relative 'transformation/composition'
+
+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 [Angle]	:angle	    Rotation angle (assumes planar geometry)
+    	# @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 = 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 }
+		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
+
+	    raise ArgumentError, "Bad translation" if @translation.is_a? Hash
+	    @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
+
+	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 || @scale || @translation)
+	end
+
+	def eql?(other)
+	    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)
+	    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)
+	    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}. 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)
+	    point = @rotation.transform(point) if @rotation
+	    @translation ? (@translation + point) : point
+	end
+    end
+end

data/lib/geometry/triangle.rb

@@ -0,0 +1,78 @@
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+=begin rdoc
+A {http://en.wikipedia.org/wiki/Triangle Triangle} is not a square.
+
+== Usage
+A right {Triangle} with its right angle at the origin and sides of length 1
+    triangle = Geometry::Triangle.new [0,0], [1,0], [0,1]
+
+An isoscoles right {Triangle} created with an origin and leg length
+    triangle = Geometry::Triangle.new [0,0], 1
+=end
+
+    # @abstract Factory class that instantiates the appropriate subclasses
+    class Triangle
+
+	include ClusterFactory
+
+	# @overload new(point0, point1, point2)
+	#   Contruct a {ScaleneTriangle} using three {Point}s
+	#   @param [Point] point0   The first vertex of the {Triangle}
+	#   @param [Point] point1   Another vertex of the {Triangle}
+	#   @param [Point] point2   The final vertex of the {Triangle}
+	# @overload new(point, length)
+	#   Construct a {RightTriangle} using a {Point} and the lengths of the sides
+	#   @param [Point] point    The location of the vertex at {Triangle}'s right angle
+	#   @param [Number] base    The length of the {Triangle}'s base leg
+	#   @param [Number] height  The length of the {Triangle}'s vertical leg
+	def self.new(*args)
+	     if args.size == 3
+		ScaleneTriangle.new *args
+	     elsif args.size == 2
+		RightTriangle.new args[0], args[1], args[1]
+	     end
+	end
+    end
+
+    # {http://en.wikipedia.org/wiki/Equilateral_triangle Equilateral Triangle}
+    class EquilateralTriangle < Triangle
+	def self.new(*args)
+	    original_new(*args)
+	end
+    end
+
+    class IsoscelesTriangle < Triangle
+	def self.new(*args)
+	    original_new(*args)
+	end
+    end
+
+    # {http://en.wikipedia.org/wiki/Right_triangle Right Triangle}
+    class RightTriangle < Triangle
+	attr_reader :origin, :base, :height
+
+	# Construct a Right Triangle given a {Point} and the leg lengths
+	def initialize(origin, base, height)
+	    @origin = Point[origin]
+	    @base, @height = base, height
+	end
+
+	# An array of points corresponding to the vertices of the {Triangle} (clockwise)
+	# @return [Array<Point>]    Vertices
+	def points
+	    [@origin, @origin + Point[0,@height], @origin + Point[@base,0]]
+	end
+    end
+
+    class ScaleneTriangle < Triangle
+	attr_reader :points
+
+	# Construct a scalene {Triangle}
+	def initialize(point0, point1, point2)
+	    @points = [point0, point1, point2].map {|p| Point[p] }
+	end
+    end
+end

data/lib/geometry/vector.rb

@@ -0,0 +1,34 @@
+require 'matrix'
+
+# Monkeypatch Vector to overcome some deficiencies
+class Vector
+    X = Vector[1,0,0]
+    Y = Vector[0,1,0]
+    Z = Vector[0,0,1]
+
+# @group Unary operators
+    def +@
+	self
+    end
+
+    def -@
+	Vector[*(@elements.map {|e| -e })]
+    end
+# @endgroup
+
+    # Cross-product of two {Vector}s
+    # @return [Vector]
+    def cross(other)
+	Vector.Raise ErrDimensionMismatch unless @elements.size == other.size
+	
+	case @elements.size
+	    when 0 then raise ArgumentError, "Can't multply zero-length Vectors"
+	    when 1 then @elements.first * other.first
+	    when 2 then @elements.first * other[1] - @elements.last * other.first
+	    when 3 then Vector[ @elements[1]*other[2] - @elements[2]*other[1],
+				@elements[2]*other[0] - @elements[0]*other[2],
+				@elements[0]*other[1] - @elements[1]*other[0]]
+	end
+    end
+    alias ** cross
+end

data/lib/geometry.rb

@@ -0,0 +1,22 @@
+require_relative 'geometry/arc'
+require_relative 'geometry/circle'
+require_relative 'geometry/line'
+require_relative 'geometry/obround'
+require_relative 'geometry/path'
+require_relative 'geometry/point'
+require_relative 'geometry/point_zero'
+require_relative 'geometry/polygon'
+require_relative 'geometry/polyline'
+require_relative 'geometry/rectangle'
+require_relative 'geometry/regular_polygon'
+require_relative 'geometry/rotation'
+require_relative 'geometry/size'
+require_relative 'geometry/size_zero'
+require_relative 'geometry/square'
+require_relative 'geometry/transformation'
+require_relative 'geometry/triangle'
+require_relative 'geometry/vector'
+require_relative 'geometry/text'
+
+module Geometry
+end

data/test/geometry/arc.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require 'geometry/arc'
+
+describe Geometry::Arc do
+    Arc = Geometry::Arc
+
+    describe "when constructed" do
+	it "must accept a center point, radius, start and end angles" do
+	    arc = Geometry::Arc.new center:[1,2], radius:3, start:0, end: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
+
+	it "must create an Arc from center, start and end points" do
+	    arc = Geometry::Arc.new center:[1,2], start:[3,4], end:[5,6]
+	    arc.must_be_kind_of Geometry::Arc
+	    arc.center.must_equal Point[1,2]
+	    arc.first.must_equal Point[3,4]
+	    arc.last.must_equal Point[5,6]
+	end
+    end
+end

data/test/geometry/circle.rb

@@ -0,0 +1,112 @@
+require 'minitest/autorun'
+require 'geometry/circle'
+
+describe Geometry::Circle do
+    Circle = Geometry::Circle
+
+    describe "when constructed with center and radius arguments" do
+	let(:circle) { Circle.new [1,2], 3 }
+
+	it "must create a Circle" do
+	    circle.must_be_instance_of(Circle)
+	end
+	
+	it "must have a center point accessor" do
+	    circle.center.must_equal Point[1,2]
+	end
+	
+	it "must have a radius accessor" do
+	    circle.radius.must_equal 3
+	end
+
+	it "must compare equal" do
+	    circle.must_equal Circle.new([1,2], 3)
+	end
+    end
+
+    describe "when constructed with named center and radius arguments" do
+	let(:circle) { Circle.new :center => [1,2], :radius => 3 }
+	
+	it "must create a Circle" do
+	    circle.must_be_instance_of(Circle)
+	end
+	
+	it "must have a center point accessor" do
+	    circle.center.must_equal Point[1,2]
+	end
+	
+	it "must have a radius accessor" do
+	    circle.radius.must_equal 3
+	end
+
+	it "must compare equal" do
+	    (circle == Circle.new(:center => [1,2], :radius => 3)).must_equal true
+	end
+    end
+
+    describe "when constructed with named center and diameter arguments" do
+	let(:circle) { Circle.new center:[1,2], diameter:4 }
+
+	it "must be a CenterDiameterCircle" do
+	    circle.must_be_instance_of(Geometry::CenterDiameterCircle)
+	    circle.must_be_kind_of(Circle)
+	end
+
+	it "must have a center" do
+	    circle.center.must_equal Point[1,2]
+	end
+
+	it "must have a diameter" do
+	    circle.diameter.must_equal 4
+	end
+
+	it "must calculate the correct radius" do
+	    circle.radius.must_equal 2
+	end
+
+	it "must compare equal" do
+	    circle.must_equal Circle.new([1,2], :diameter => 4)
+	end
+    end
+
+    describe "when constructed with a diameter and no center" do
+	let(:circle) { Circle.new :diameter => 4 }
+
+	it "must be a CenterDiameterCircle" do
+	    circle.must_be_instance_of(Geometry::CenterDiameterCircle)
+	    circle.must_be_kind_of(Circle)
+	end
+
+	it "must have a nil center" do
+	    circle.center.must_be_kind_of Geometry::PointZero
+	end
+
+	it "must have a diameter" do
+	    circle.diameter.must_equal 4
+	end
+
+	it "must calculate the correct radius" do
+	    circle.radius.must_equal 2
+	end
+    end
+
+    describe "properties" do
+	subject { Circle.new center:[1,2], :diameter => 4 }
+
+	it "must have a bounds property that returns a Rectangle" do
+	    subject.bounds.must_equal Rectangle.new([-1,0], [3,4])
+	end
+
+	it "must have a minmax property that returns the corners of the bounding rectangle" do
+	    subject.minmax.must_equal [Point[-1,0], Point[3,4]]
+	end
+
+	it "must have a max property that returns the upper right corner of the bounding rectangle" do
+	    subject.max.must_equal Point[3,4]
+	end
+
+	it "must have a min property that returns the lower left corner of the bounding rectangle" do
+	    subject.min.must_equal Point[-1,0]
+	end
+    end
+end

data/test/geometry/edge.rb

@@ -0,0 +1,132 @@
+require 'minitest/autorun'
+require 'geometry/edge'
+
+def Edge(*args)
+    Geometry::Edge.new(*args)
+end
+
+describe Geometry::Edge do
+    Edge = Geometry::Edge
+    subject { Geometry::Edge.new [0,0], [1,1] }
+
+    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
+
+    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)
+	edge1.wont_equal edge3
+    end
+
+    it "must return the height of the edge" do
+	edge = Edge([0,0], [1,1])
+	assert_equal(1, edge.height)
+    end
+
+    it "must return the width of the edge" do
+	edge = Edge([0,0], [1,1])
+	assert_equal(1, edge.width)
+    end
+
+    it "must convert an Edge to a Vector" do
+	Edge.new([0,0], [1,0]).vector.must_equal Vector[1,0]
+    end
+
+    it "must return the normalized direction of a vector" do
+	Edge.new([0,0], [1,0]).direction.must_equal Vector[1,0]
+    end
+
+    it "must return true for parallel edges" do
+	Edge.new([0,0], [1,0]).parallel?(Edge.new([0,0], [1,0])).must_equal 1
+	Edge.new([0,0], [1,0]).parallel?(Edge.new([1,0], [2,0])).must_equal 1
+	Edge.new([0,0], [1,0]).parallel?(Edge.new([3,0], [4,0])).must_equal 1
+	Edge.new([0,0], [1,0]).parallel?(Edge.new([3,1], [4,1])).must_equal 1
+    end
+
+    it "must return false for non-parallel edges" do
+	Edge.new([0,0], [2,0]).parallel?(Edge.new([1,-1], [1,1])).must_equal false
+    end
+
+    it "must clone and reverse" do
+	reversed = subject.reverse
+	reversed.to_a.must_equal subject.to_a.reverse
+	reversed.wont_be_same_as subject
+    end
+
+    it "must reverse itself" do
+	original = subject.to_a
+	subject.reverse!
+	subject.to_a.must_equal original.reverse
+    end
+
+    describe "spaceship" do
+	it "ascending with a Point" do
+	    edge = Edge.new [0,0], [1,1]
+	    (edge <=> Point[0,0]).must_equal 0
+	    (edge <=> Point[1,0]).must_equal -1
+	    (edge <=> Point[0,1]).must_equal 1
+	    (edge <=> Point[2,2]).must_equal nil
+	end
+
+	it "descending with a Point" do
+	    edge = Edge.new [1,1], [0,0]
+	    (edge <=> Point[0,0]).must_equal 0
+	    (edge <=> Point[1,0]).must_equal 1
+	    (edge <=> Point[0,1]).must_equal -1
+	    (edge <=> Point[2,2]).must_equal nil
+	end
+    end
+
+    describe "when finding an intersection" do
+	it "must find the intersection of two end-intersecting Edges" do
+	    intersection = Edge.new([0,0],[1,1]).intersection(Edge.new([0,1],[1,1]))
+	    intersection.must_be_kind_of Geometry::Point
+	    intersection.must_equal Geometry::Point[1,1]
+	end
+
+	it "must find the intersection of two collinear end-intersecting Edges" do
+	    intersection = Edge.new([2,2], [0,2]).intersection(Edge.new([3,2], [2,2]))
+	    intersection.must_be_kind_of Geometry::Point
+	    intersection.must_equal Geometry::Point[2,2]
+
+	    intersection = Edge.new([0,2], [2,2]).intersection(Edge.new([2,2], [3,2]))
+	    intersection.must_be_kind_of Geometry::Point
+	    intersection.must_equal Geometry::Point[2,2]
+	end
+
+	it "must find the itersection of two crossed Edges" do
+	    edge1 = Edge.new [0.0, 0], [2.0, 2.0]
+	    edge2 = Edge.new [2.0, 0], [0.0, 2.0]
+	    intersection = edge1.intersection edge2
+	    intersection.must_be_kind_of Geometry::Point
+	    intersection.must_equal Geometry::Point[1,1]
+	end
+
+	it "must return nil for two edges that do not intersect" do
+	    Edge.new([0,0],[1,0]).intersection(Edge.new([0,1],[1,1])).must_equal nil
+	end
+
+	it "must return true for two collinear and overlapping edges" do
+	    Edge.new([0,0],[2,0]).intersection(Edge.new([1,0],[3,0])).must_equal true
+	end
+
+	it "must return false for collinear but non-overlapping edges" do
+	    Edge.new([0,0],[2,0]).intersection(Edge.new([3,0],[4,0])).must_equal false
+	    Edge.new([0,0],[0,2]).intersection(Edge.new([0,3],[0,4])).must_equal false
+	end
+
+	it "must return nil for two parallel but not collinear edges" do
+	    Edge.new([0,0],[2,0]).intersection(Edge.new([1,1],[3,1])).must_equal nil
+	end
+
+	it "must return nil for two perpendicular but not interseting edges" do
+	    Edge.new([0, 0], [2, 0]).intersection(Edge.new([3, 3], [3, 1])).must_equal nil
+	end
+    end
+end