geometry 6.2 → 6.3

data/lib/geometry/point_one.rb

@@ -0,0 +1,131 @@
+require_relative 'point'
+
+module Geometry
+=begin rdoc
+An object repesenting a {Point} that is one unit away from the origin, along each
+axis, in N-dimensional space
+
+A {PointOne} object is a {Point} that will always compare equal to one and unequal to
+everything else, regardless of size. It's similar to the
+{http://en.wikipedia.org/wiki/Null_Object_pattern Null Object Pattern}, but for ones.
+=end
+    class PointOne
+	def eql?(other)
+	    if other.respond_to? :all?
+		other.all? {|e| e.eql? 1}
+	    else
+		other == 1
+	    end
+	end
+	alias == eql?
+
+	def coerce(other)
+	    if other.is_a? Numeric
+		[other, 1]
+	    elsif other.is_a? Array
+		[other, Array.new(other.size, 1)]
+	    elsif other.is_a? Vector
+		[other, Vector[*Array.new(other.size, 1)]]
+	    else
+		[Point[other], Point[Array.new(other.size, 1)]]
+	    end
+	end
+
+	def is_a?(klass)
+	    (klass == Point) || super
+	end
+	alias :kind_of? :is_a?
+
+	# This is a hack to get Array#== to work properly. It works on ruby 2.0 and 1.9.3.
+	def to_ary
+	    []
+	end
+
+# @group Accessors
+	# @param [Integer]  i	Index into the {Point}'s elements
+	# @return [Numeric] Element i (starting at 0)
+	def [](i)
+	    1
+	end
+
+	# @attribute [r] x
+	#   @return [Numeric] X-component
+	def x
+	    1
+	end
+
+	# @attribute [r] y
+	#   @return [Numeric] Y-component
+	def y
+	    1
+	end
+
+	# @attribute [r] z
+	#   @return [Numeric] Z-component
+	def z
+	    1
+	end
+# @endgroup
+
+# @group Arithmetic
+
+# @group Unary operators
+	def +@
+	    self
+	end
+
+	def -@
+	    -1
+	end
+# @endgroup
+
+	def +(other)
+	    case other
+		when Numeric
+		    Point.iso(other + 1)
+		when Size
+		    Point[other.map {|a| a + 1 }]
+		else
+		    if other.respond_to?(:map)
+			other.map {|a| a + 1 }
+		    else
+			Point[other + 1]
+		    end
+	    end
+	end
+
+	def -(other)
+	    if other.is_a? Size
+		Point[other.map {|a| 1 - a }]
+	    elsif other.respond_to? :map
+		other.map {|a| 1 - a }
+	    elsif other == 1
+		Point.zero
+	    else
+		Point.iso(1 - other)
+	    end
+	end
+
+	def *(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    other
+	end
+
+	def /(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    raise ZeroDivisionError if 0 == other
+	    1 / other
+	end
+# @endgroup
+
+	# @group Enumerable
+
+	# Return the first, or first n, elements (always 0)
+	# @param n [Number]	the number of elements to return
+	def first(n=nil)
+	    Array.new(n, 1) rescue 1
+	end
+	# @endgroup
+    end
+end
+

data/lib/geometry/point_zero.rb

@@ -1,4 +1,5 @@
 require_relative 'point'
+require_relative 'point_iso'
 
 module Geometry
 =begin rdoc
@@ -30,6 +31,11 @@ everything else, regardless of size. You can think of it as an application of th
 	    end
 	end
 
+	def is_a?(klass)
+	    (klass == Point) || super
+	end
+	alias :kind_of? :is_a?
+
 	# This is a hack to get Array#== to work properly. It works on ruby 2.0 and 1.9.3.
 	def to_ary
 	    []
@@ -75,7 +81,9 @@ everything else, regardless of size. You can think of it as an application of th
 
 	def +(other)
 	    case other
-		when Array, Numeric then other
+		when Array then other
+		when Numeric
+		    Point.iso(other)
 		else
 		    Point[other]
 	    end
@@ -84,6 +92,8 @@ everything else, regardless of size. You can think of it as an application of th
 	def -(other)
 	    if other.is_a? Size
 		-Point[other]
+	    elsif other.is_a? Numeric
+		Point.iso(-other)
 	    elsif other.respond_to? :-@
 		-other
 	    elsif other.respond_to? :map
@@ -102,6 +112,14 @@ everything else, regardless of size. You can think of it as an application of th
 	end
 # @endgroup
 
+	# @group Enumerable
+
+	# Return the first, or first n, elements (always 0)
+	# @param n [Number]	the number of elements to return
+	def first(n=nil)
+	    Array.new(n, 0) rescue 0
+	end
+	# @endgroup
     end
 end
 

data/lib/geometry/polygon.rb

@@ -18,11 +18,11 @@ but there's currently nothing that enforces simplicity.
     class Polygon < Polyline
 
 	# Construct a new Polygon from Points and/or Edges
-	#  The constructor will try to convert all of its arguments into Points and
-	#   Edges. Then successive Points will be collpased into Edges. Successive
-	#   Edges that share a common vertex will be added to the new Polygon. If
-	#   there's a gap between Edges it will be automatically filled with a new
-	#   Edge. The resulting Polygon will then be closed if it isn't already.
+	#  The constructor will try to convert all of its arguments into {Points} and
+	#   {Edges}. Then successive {Points} will be collpased into {Edges}. Successive
+	#   {Edges} that share a common vertex will be added to the new {Polygon}. If
+	#   there's a gap between {Edges} it will be automatically filled with a new
+	#   {Edge}. The resulting Polygon will then be closed, if it isn't already.
 	# @overload initialize(Edge, Edge, ...)
 	#   @return [Polygon]
 	# @overload initialize(Point, Point, ...)
@@ -116,7 +116,7 @@ but there's currently nothing that enforces simplicity.
 			if (a.first == b.first) and (a.last == b.last)	    # Equal edges
 			elsif (a.first == b.last) and (a.last == b.first)   # Ignore equal but opposite edges
 			else
-			    if a.vector.normalize == b.vector.normalize # Same direction?
+			    if a.direction == b.direction # Same direction?
 				offsetA += 1 if ringA.insert_boundary(indexA + 1 + offsetA, b.first)
 				offsetB += 1 if ringB.insert_boundary(indexB + 1 + offsetB, a.last)
 			    else    # Opposite direction

data/lib/geometry/polyline.rb

@@ -15,6 +15,10 @@ also like a {Path} in that it isn't necessarily closed.
     class Polyline
 	attr_reader :edges, :vertices
 
+	# @!attribute points
+	#   @return [Array<Point>]  all of the vertices of the {Polyline} (alias of #vertices)
+	alias :points :vertices
+
 	# Construct a new Polyline from Points and/or Edges
 	# @note The constructor will try to convert all of its arguments into {Point}s and
 	#   {Edge}s. Then successive {Point}s will be collpased into {Edge}s. Successive

data/lib/geometry/rectangle.rb

@@ -123,6 +123,12 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    Point[(max.x+min.x)/2, (max.y+min.y)/2]
 	end
 
+	# @!attribute closed?
+	#   @return [Bool]  always true
+	def closed?
+	    true
+	end
+
 	# @return [Array<Edge>]   The {Rectangle}'s four edges (counterclockwise)
 	def edges
 	    point0, point2 = *@points

data/lib/geometry/regular_polygon.rb

@@ -1,4 +1,3 @@
-require_relative 'cluster_factory'
 require_relative 'polygon'
 
 module Geometry
@@ -10,53 +9,49 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 == Usage
     polygon = Geometry::RegularPolygon.new sides:4, center:[1,2], radius:3
     polygon = Geometry::RegularPolygon.new sides:6, center:[1,2], diameter:6
+
+    polygon = Geometry::RegularPolygon.new sides:4, center:[1,2], inradius:3
+    polygon = Geometry::RegularPolygon.new sides:6, center:[1,2], indiameter: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}
+	#   @option options [Number]	:radius The circumradius of the {RegularPolygon}
+	# @overload new(sides, center, inradius)
+	#   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]	:inradius   The inradius 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}
+	#   @option options [Number]	:diameter   The circumdiameter of the {RegularPolygon}
+	# @overload new(sides, center, indiameter)
+	#   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]	:indiameter   The circumdiameter of the {RegularPolygon}
 	# @return   [RegularPolygon]	A new {RegularPolygon} object
-	def initialize(edge_count, center, radius)
-	    @center = Point[center]
-	    @edge_count = edge_count
+	def initialize(edge_count:nil, sides:nil, center:nil, radius:nil, diameter:nil, indiameter:nil, inradius:nil)
+	    @edge_count = edge_count || sides
+	    raise ArgumentError, "RegularPolygon requires an edge count" unless @edge_count
+
+	    raise ArgumentError, "RegularPolygon.new requires a radius or a diameter" unless diameter || indiameter || inradius || radius
+
+	    @center = center ? Point[center] : Point.zero
+	    @diameter = diameter
+	    @indiameter = indiameter
+	    @inradius = inradius
 	    @radius = radius
 	end
 
@@ -65,6 +60,12 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 	end
 	alias :== :eql?
 
+	# Check to see if the {Polygon} is closed (always true)
+	# @return [True] Always true because a {Polygon} is always closed
+	def closed?
+	    true
+	end
+
 # @!group Accessors
 	# @return [Rectangle]	The smallest axis-aligned {Rectangle} that bounds the receiver
 	def bounds
@@ -74,8 +75,9 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 	# @!attribute [r] diameter
 	#   @return [Numeric] The diameter of the {RegularPolygon}
 	def diameter
-	    @radius*2
+	    @diameter || (@radius && 2*@radius) || (@indiameter && @indiameter/cosine_half_angle)
 	end
+	alias :circumdiameter :diameter
 
 	# !@attribute [r] edges
 	def edges
@@ -88,6 +90,7 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 	def vertices
 	    (0...2*Math::PI).step(2*Math::PI/edge_count).map {|angle| center + Point[Math::cos(angle), Math::sin(angle)]*radius }
 	end
+	alias :points :vertices
 
 	# @return [Point]   The upper right corner of the bounding {Rectangle}
 	def max
@@ -103,34 +106,38 @@ A {RegularPolygon} is a lot like a {Polygon}, but more regular.
 	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
+	# @!attribute indiameter
+	#   @return [Number]  the indiameter
+	def indiameter
+	    @indiameter || (@inradius && 2*@inradius) || (@diameter && (@diameter * cosine_half_angle)) || (@radius && (2 * @radius * cosine_half_angle))
 	end
 
-	def eql?(other)
-	    (self.center == other.center) && (self.edge_count == other.edge_count) && (self.diameter == other.diameter)
+	# @!attribute inradius
+	#   @return [Number]  The inradius
+	def inradius
+	    @inradius || (@indiameter && @indiameter/2) || (@radius && (@radius * cosine_half_angle))
 	end
-	alias :== :eql?
+	alias :apothem :inradius
 
-# @!group Accessors
-	# @return [Number] The {RegularPolygon}'s radius
+	# @!attribute [r] radius
+	# @return [Number]  The {RegularPolygon}'s radius
 	def radius
-	    @diameter/2
+	    @radius || (@diameter && @diameter/2) || (@inradius && (@inradius / cosine_half_angle)) || (@indiameter && @indiameter/cosine_half_angle/2)
+	end
+	alias :circumradius :radius
+
+	# @!attribute [r] side_length
+	#   @return [Number]  The length of each side
+	def side_length
+	    2 * circumradius * Math.sin(Math::PI/edge_count)
 	end
+
+private
+	def cosine_half_angle
+	    Math.cos(Math::PI/edge_count)
+	end
+
 # @!endgroup
     end
 end

data/lib/geometry/rotation.rb

@@ -105,6 +105,7 @@ A generalized representation of a rotation transformation.
 	# @param [Point] point	the {Point} to rotate into the parent coordinate frame
 	# @return [Point]   the rotated {Point}
 	def transform(point)
+	    return point if point.is_a?(PointZero)
 	    m = matrix
 	    m ? Point[m * Point[point]] : point
 	end

data/lib/geometry/size.rb

@@ -1,5 +1,8 @@
 require 'matrix'
 
+require_relative 'size_one'
+require_relative 'size_zero'
+
 module Geometry
 =begin
 An object representing the size of something.
@@ -29,13 +32,42 @@ methods (width, height and depth).
 	    array.flatten!
 	    super *array
 	end
-	
+
+	# Creates and returns a new {SizeOne} instance. Or, a {Size} full of ones if the size argument is given.
+	# @param size [Number] the size of the new {Size} full of ones
+	# @return [SizeOne] A new {SizeOne} instance
+	def self.one(size=nil)
+	    size ? Size[Array.new(size, 1)] : SizeOne.new
+	end
+
+	# Creates and returns a new {SizeOne} instance. Or, a {Size} full of zeros if the size argument is given.
+	# @param size [Number] the size of the new {Size} full of zeros
+	# @return [SizeOne] A new {SizeOne} instance
+	def self.zero(size=nil)
+	    size ? Size[Array.new(size, 0)] : SizeOne.new
+	end
+
 	# Allow comparison with an Array, otherwise do the normal thing
 	def ==(other)
 	    return @elements == other if other.is_a?(Array)
 	    super other
 	end
 
+	# Override Vector#[] to allow for regular array slicing
+	def [](*args)
+	    @elements[*args]
+	end
+
+	def coerce(other)
+	    case other
+		when Array then [Size[*other], self]
+		when Numeric then [Size[Array.new(self.size, other)], self]
+		when Vector then [Size[*other], self]
+		else
+		raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+	    end
+	end
+
 	def inspect
 	    'Size' + @elements.inspect
 	end
@@ -91,13 +123,12 @@ methods (width, height and depth).
 		left = top = -args.shift
 		right = bottom = 0
 	    elsif 2 == args.size
-		left = -args.shift
-		top = -args.shift
-		right = bottom = 0
+		left = right = -args.shift
+		top = bottom = -args.shift
 	    end
 
-	    left = -options[:x] if options[:x]
-	    top = -options[:y] if options[:y]
+	    left = right = -options[:x] if options[:x]
+	    top = bottom = -options[:y] if options[:y]
 
 	    top = -options[:top] if options[:top]
 	    left = -options[:left] if options[:left]
@@ -125,13 +156,12 @@ methods (width, height and depth).
 		left = top = args.shift
 		right = bottom = 0
 	    elsif 2 == args.size
-		left = args.shift
-		top = args.shift
-		right = bottom = 0
+		left = right = args.shift
+		top = bottom = args.shift
 	    end
 
-	    left = options[:x] if options[:x]
-	    top = options[:y] if options[:y]
+	    left = right = options[:x] if options[:x]
+	    top = bottom = options[:y] if options[:y]
 
 	    top = options[:top] if options[:top]
 	    left = options[:left] if options[:left]