Class: Geometry::Rectangle

Inherits:
Object
  • Object
show all
Includes:
ClusterFactory
Defined in:
lib/geometry/rectangle.rb

Overview

The Rectangle class cluster represents your typical arrangement of 4 corners and 4 sides.

Usage

Constructors

rect = Rectangle.new [1,2], [2,3]		    # Using two corners
rect = Rectangle.new from:[1,2], to:[2,3]	    # Using two corners

rect = Rectangle.new center:[1,2], size:[1,1]   # Using a center point and a size
rect = Rectangle.new origin:[1,2], size:[1,1]   # Using an origin point and a size

rect = Rectangle.new size: [10, 20]         # origin = [0,0], size = [10, 20]
rect = Rectangle.new size: Size[10, 20]	# origin = [0,0], size = [10, 20]
rect = Rectangle.new width: 10, height: 20	# origin = [0,0], size = [10, 20]

Direct Known Subclasses

CenteredRectangle, SizedRectangle

Accessors collapse

Instance Attribute Summary collapse

Accessors collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ClusterFactory

included

Constructor Details

#initialize(point0, point1) ⇒ Rectangle

Creates a Geometry::Rectangle using the given Points

@param [Point]	point0	A corner (ie. bottom-left)
@param [Point]	point1	The other corner (ie. top-right)

Raises:

  • (ArgumentError) 


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/geometry/rectangle.rb', line 91

def initialize(point0, point1)
    point0 = Point[point0]
    point1 = Point[point1]
    raise(ArgumentError, "Point sizes must match") unless point0.size == point1.size

    # Reorder the points to get lower-left and upper-right
    if (point0.x > point1.x) && (point0.y > point1.y)
	point0, point1 = point1, point0
    else
	p0x, p1x = [point0.x, point1.x].minmax
	p0y, p1y = [point0.y, point1.y].minmax
	point0 = Point[p0x, p0y]
	point1 = Point[p1x, p1y]
    end
    @points = [point0, point1]
end

Instance Attribute Details

#center ⇒ Point (readonly)

Returns The Geometry::Rectangle‘s center.

Returns:



29
30
31
 
# File 'lib/geometry/rectangle.rb', line 29

def center
  @center
end

#height ⇒ Number (readonly)

Returns Height of the Geometry::Rectangle.

Returns:



31
32
33
 
# File 'lib/geometry/rectangle.rb', line 31

def height
  @height
end

#origin ⇒ Point (readonly)

Returns The Geometry::Rectangle‘s origin.

Returns:



33
34
35
 
# File 'lib/geometry/rectangle.rb', line 33

def origin
  @origin
end

#size ⇒ Size (readonly)

Returns The Size of the Geometry::Rectangle.

Returns:



35
36
37
 
# File 'lib/geometry/rectangle.rb', line 35

def size
  @size
end

#width ⇒ Number (readonly)

Returns Width of the Geometry::Rectangle.

Returns:



37
38
39
 
# File 'lib/geometry/rectangle.rb', line 37

def width
  @width
end

Class Method Details

.new(width, height) ⇒ CenteredRectangle .new(size) ⇒ CenteredRectangle .new(point0, point1) ⇒ Object .new(origin, size) ⇒ SizedRectangle .new(left, bottom, right, top) ⇒ Object

Overloads:



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/geometry/rectangle.rb', line 63

def self.new(*args)
    options, args = args.partition {|a| a.is_a? Hash}
    options = options.reduce({}, :merge)

    if options.has_key?(:size)
	if options.has_key?(:center)
	    CenteredRectangle.new(center: options[:center], size: options[:size])
	elsif options.has_key?(:origin)
	    SizedRectangle.new(origin: options[:origin], size: options[:size])
	else
	    SizedRectangle.new(size: options[:size])
	end
    elsif options.has_key?(:from) and options.has_key?(:to)
	original_new(options[:from], options[:to])
    elsif options.has_key?(:height) and options.has_key?(:width)
	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
end

Instance Method Details

#bounds ⇒ Rectangle

Returns The smallest axis-aligned Geometry::Rectangle that bounds the receiver.

Returns:



116
117
118
 
# File 'lib/geometry/rectangle.rb', line 116

def bounds
    return Rectangle.new(self.min, self.max)
end

#edges ⇒ Array<Edge>

Returns The Geometry::Rectangle‘s four edges (counterclockwise).

Returns:



127
128
129
130
131
132
133
134
135
 
# File 'lib/geometry/rectangle.rb', line 127

def edges
    point0, point2 = *@points
    point1 = Point[point2.x, point0.y]
    point3 = Point[point0.x, point2.y]
    [Edge.new(point0, point1),
     Edge.new(point1, point2),
     Edge.new(point2, point3),
     Edge.new(point3, point0)]
end

#eql?(other) ⇒ Boolean Also known as: ==

Returns:

  • (Boolean) 


108
109
110
 
# File 'lib/geometry/rectangle.rb', line 108

def eql?(other)
    self.points == other.points
end

#inset(x, y) ⇒ Object #inset(top, left, bottom, right) ⇒ Object #inset(x, y) ⇒ Object #inset(top, left, bottom, right) ⇒ Object

Create a new Geometry::Rectangle from the receiver that’s inset by the given amount

Overloads:

  • #inset(x, y) ⇒ Object
  • #inset(top, left, bottom, right) ⇒ Object

Raises:

  • (ArumentError) 


188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/geometry/rectangle.rb', line 188

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

#max ⇒ Point

Returns The upper right corner of the bounding Geometry::Rectangle.

Returns:



138
139
140
 
# File 'lib/geometry/rectangle.rb', line 138

def max
    @points.last
end

#min ⇒ Point

Returns The lower left corner of the bounding Geometry::Rectangle.

Returns:



143
144
145
 
# File 'lib/geometry/rectangle.rb', line 143

def min
    @points.first
end

#minmax ⇒ Array<Point>

Returns The lower left and upper right corners of the bounding Geometry::Rectangle.

Returns:



148
149
150
 
# File 'lib/geometry/rectangle.rb', line 148

def minmax
    [self.min, self.max]
end

#points ⇒ Array<Point>

Returns The Geometry::Rectangle‘s four points (counterclockwise).

Returns:



153
154
155
156
157
158
 
# File 'lib/geometry/rectangle.rb', line 153

def points
    point0, point2 = *@points
    point1 = Point[point2.x, point0.y]
    point3 = Point[point0.x, point2.y]
    [point0, point1, point2, point3]
end