aurora-geometry 0.0.2

data/lib/geometry/square.rb

@@ -0,0 +1,113 @@
+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 from:[1,2], to:[2,3]	# Using two corners
+    square = Square.new origin:[3,4], size:5	# Using an origin point and a size
+=end
+    class Square
+	attr_reader :origin
+
+	# Creates a {Square} given two {Point}s
+	# @option options [Point] :from	A corner (ie. bottom-left)
+	# @option options [Point] :to	The other corner (ie. top-right)
+	# @option options [Point] :origin   The lower left corner
+	# @option options [Number] :size    Bigness
+	def initialize(options={})
+	    origin = options[:from] || options[:origin]
+	    origin = origin ? Point[origin] : PointZero.new
+
+	    if options.has_key? :to
+		point1 = options[:to]
+	    elsif options.has_key? :size
+		point1 = origin + options[:size]
+	    end
+
+	    point1 = Point[point1]
+	    raise(ArgumentError, "Point sizes must match (#{origin.size} != #{point1.size})") unless origin.is_a?(PointZero) || (origin.size == point1.size)
+
+	    # Reorder the points to get lower-left and upper-right
+	    minx, maxx = [origin.x, point1.x].minmax
+	    miny, maxy = [origin.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 (counterclockwise)
+	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[maxx, miny], Point[maxx, maxy], Point[minx,maxy]]
+	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/text.rb

@@ -0,0 +1,24 @@
+require_relative 'point'
+
+module Geometry
+
+	class Text
+		
+		# @return [Point]   The point located in the top left corner of {Text}'s
+		# bounding box
+		attr_reader :position
+
+		# @return [String]  The {Text}'s textual content
+		attr_reader :content
+		
+		def initialize(position, content)
+			@position = Point[position]
+			@content = content
+		end
+		
+		def eql?(other)
+			self.content == other.content
+		end
+		alias :== :eql?
+	end
+end

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/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

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