def test_skyline10(self):
"""
+---------------------------+
| |
| |
| |
| |
| +----+
| | |
| | |
| | |
+----------------+ | |
| | | |
| +-----+ 3 |
| 1 | | |
| | 2 | |
| | | |
| | | |
+----------------+-----+----+
With rotation
"""
s = skyline.SkylineMwfl(100, 100, rot=True)
rect1 = s.add_rect(50, 40)
rect2 = s.add_rect(30, 30)
rect3 = s.add_rect(70, 20)
self.assertEqual(rect1, Rectangle(0, 0, 50, 40))
self.assertEqual(rect2, Rectangle(50, 0, 30, 30))
self.assertEqual(rect3, Rectangle(80, 0, 20, 70))
def test_skyline(self):
"""
+---------------------------+
| |
| |
+----+ +------------------+
| | | 5 |
| | +---+--+-----------+
| | | | |
| | | | |
| | | | |
| 1 | | | |
| | | +-----------+
| +-------+ 3| |
| | | | |
| | | | 4 |
| | 2 | | |
| | | | |
+----+-------+--+-----------+
"""
s = skyline.SkylineMwf(100, 100, rot=False)
rect1 = s.add_rect(20, 80)
rect2 = s.add_rect(20, 40)
rect3 = s.add_rect(20, 70)
rect4 = s.add_rect(40, 50)
rect5 = s.add_rect(70, 10)
self.assertEqual(rect1, Rectangle(0, 0, 20, 80))
self.assertEqual(rect2, Rectangle(20, 0, 20, 40))
self.assertEqual(rect3, Rectangle(40, 0, 20, 70))
self.assertEqual(rect4, Rectangle(60, 0, 40, 50))
self.assertEqual(rect5, Rectangle(30, 70, 70, 10))
def test_select_position(self):
m = maxrects.MaxRectsBl(100, 100, rot=False)
self.assertEqual(m.add_rect(40, 40), Rectangle(0, 0, 40, 40))
self.assertFalse(m.add_rect(100, 100))
self.assertEqual(m.add_rect(20, 20), Rectangle(40, 0, 20, 20))
self.assertEqual(m.add_rect(60, 40), Rectangle(40, 20, 60, 40))
def test_skyline6(self):
"""
+-------------+-------------+
| | |
| 4 | |
| +-------------+
| | |
+-------------* 5 |
| 3 | |
| | |
+-------------+--+----------+
| | |
| 2 | |
| | |
+----------------+----+ |
| | |
| 1 | |
| | |
+---------------------+-----+
"""
s = skyline.SkylineMwflWm(100, 100, rot=False)
rect1 = s.add_rect(80, 30)
rect2 = s.add_rect(60, 20)
rect3 = s.add_rect(50, 20)
rect4 = s.add_rect(50, 30)
rect5 = s.add_rect(50, 30)
self.assertEqual(rect1, Rectangle(0, 0, 80, 30))
self.assertEqual(rect2, Rectangle(0, 30, 60, 20))
self.assertEqual(rect3, Rectangle(0, 50, 50, 20))
self.assertEqual(rect4, Rectangle(0, 70, 50, 30))
self.assertEqual(rect5, Rectangle(50, 50, 50, 30))
def test_skyline1(self):
"""
+---------------------------+
| |
| |
| |
| |
| |
| |
+-------------+-------------+
| 4 | |
| | |
+---------+---+ |
| | | 3 |
| | | |
| 1 +---+ |
| | 2 | |
| | | |
+---------+---+-------------+
Test lower positions is better than one not losing space
"""
s = skyline.SkylineBl(100, 100, rot=False)
rect1 = s.add_rect(40, 30)
rect2 = s.add_rect(10, 20)
rect3 = s.add_rect(50, 50)
rect4 = s.add_rect(50, 20)
self.assertEqual(rect1, Rectangle(0, 0, 40, 30))
self.assertEqual(rect2, Rectangle(40, 0, 10, 20))
self.assertEqual(rect3, Rectangle(50, 0, 50, 50))
self.assertEqual(rect4, Rectangle(0, 30, 50, 20))
def test_skyline(self):
"""
+---------------------------+
| |
| |
| |
| |
| |
| |
| |
| |
| |
+-----------+---------------+
| | 3 |
| | |
| 1 +---------+-----+
| | 2 | w1 |
| | | |
+-----------+---------+-----+
"""
s = skyline.SkylineMwflWm(100, 100, rot=False)
rect1 = s.add_rect(40, 40)
rect2 = s.add_rect(40, 20)
rect3 = s.add_rect(60, 20)
w1 = s.add_rect(20, 20)
self.assertEqual(rect1, Rectangle(0, 0, 40, 40))
self.assertEqual(rect2, Rectangle(40, 0, 40, 20))
self.assertEqual(rect3, Rectangle(40, 20, 60, 20))
self.assertEqual(w1, Rectangle(80, 0, 20, 20))
def test_skyline1(self):
"""
+---------------------------+
| |
| |
| |
| |
+--------------------+ |
| | |
| 4 | |
| | |
| | |
+----------------+---+------+
| | 3 |
| | |
| 1 +-----+----+
| | 2 | w1 |
| | | |
+----------------+-----+----+
"""
s = skyline.SkylineBlWm(100, 100, rot=False)
rect1 = s.add_rect(50, 40)
rect2 = s.add_rect(30, 20)
rect3 = s.add_rect(50, 20)
rect4 = s.add_rect(70, 30)
w1 = s.add_rect(20, 20)
self.assertEqual(rect1, Rectangle(0, 0, 50, 40))
self.assertEqual(rect2, Rectangle(50, 0, 30, 20))
self.assertEqual(rect3, Rectangle(50, 20, 50, 20))
self.assertEqual(rect4, Rectangle(0, 40, 70, 30))
self.assertEqual(w1, Rectangle(80, 0, 20, 20))
def test_skyline2(self):
"""
+---------------------------+
| |
| |
| +--------------------+
| | 4 |
| | |
+----+ +-----------+--------+
| | | |
| | | |
| | | |
| | | |
| 1 | | 3 |
| | | |
| | | |
| +-------------+ |
| | 2 | |
+----+-------------+--------+
"""
s = skyline.SkylineMwfl(100, 100, rot=False)
rect1 = s.add_rect(20, 60)
rect2 = s.add_rect(50, 10)
rect3 = s.add_rect(30, 60)
rect4 = s.add_rect(70, 20)
self.assertEqual(rect1, Rectangle(0, 0, 20, 60))
self.assertEqual(rect2, Rectangle(20, 0, 50, 10))
self.assertEqual(rect3, Rectangle(70, 0, 30, 60))
self.assertEqual(rect4, Rectangle(30, 60, 70, 20))
def test_skyline1(self):
"""Test skyline for complex positions is generated correctly
+---------------------------+
| |
+---------------------+ |
| 4 | |
+----------------+----+ |
| 3 | |
+----------+-----+ +-----+
| | | |
| | | 5 |
| 1 | | |
| | | |
| +----------+-----+
| | 2 |
+----------+----------------+
"""
s = skyline.SkylineMwf(100, 100, rot=False)
rect1 = s.add_rect(40, 60)
rect2 = s.add_rect(60, 10)
rect3 = s.add_rect(70, 20)
rect4 = s.add_rect(80, 20)
rect5 = s.add_rect(20, 40)
self.assertEqual(rect1, Rectangle(0, 0, 40, 60))
self.assertEqual(rect2, Rectangle(40, 0, 60, 10))
self.assertEqual(rect3, Rectangle(0, 60, 70, 20))
self.assertEqual(rect4, Rectangle(0, 80, 80, 20))
self.assertEqual(rect5, Rectangle(80, 10, 20, 40))
def test_rect_fitness(self):
m = maxrects.MaxRectsBaf(100, 100, rot=False)
self.assertEqual(m.add_rect(60, 10), Rectangle(0, 0, 60, 10))
self.assertTrue(m.fitness(40, 40) < m.fitness(50, 50))
self.assertTrue(m.fitness(40, 40) < m.fitness(35, 35))
self.assertEqual(m.add_rect(40, 40), Rectangle(60, 0, 40, 40))
def test_skyline1(self):
"""
+---------------------------+
| |
| |
| |
| |
| |
| |
| +--------+
+------------------+ 3 |
| | |
| +--------+
| | |
| 1 | |
| | 2 |
| | |
| | |
+------------------+--------+
"""
s = skyline.SkylineMwfl(100, 100, rot=True)
rect1 = s.add_rect(70, 50)
rect2 = s.add_rect(40, 30)
rect3 = s.add_rect(20, 30)
self.assertEqual(rect1, Rectangle(0, 0, 70, 50))
self.assertEqual(rect2, Rectangle(70, 0, 30, 40))
self.assertEqual(rect3, Rectangle(70, 40, 30, 20))
def test_add_waste(self):
w = waste.WasteManager()
w.add_waste(30, 40, 50, 50)
w.add_waste(5, 5, 20, 20)
w.add_waste(0, 100, 100, 100)
rect1 = w.add_rect(20, 20)
rect2 = w.add_rect(45, 40)
rect3 = w.add_rect(90, 80)
rect4 = w.add_rect(100, 100)
rect5 = w.add_rect(10, 10)
self.assertEqual(rect1, Rectangle(5, 5, 20, 20))
self.assertEqual(rect2, Rectangle(30, 40, 45, 40))
self.assertEqual(rect3, Rectangle(0, 100, 90, 80))
self.assertEqual(rect4, None)
self.assertEqual(rect5, Rectangle(30, 80, 10, 10))
self.assertEqual(len(w), 4)
# Test merge is enabled for new waste
w = waste.WasteManager()
w.add_waste(0, 0, 50, 50)
w.add_waste(50, 0, 50, 50)
self.assertEqual(len(w._sections), 1)
self.assertEqual(w.add_rect(100, 50), Rectangle(0, 0, 100, 50))
def test_lt(self):
r1 = Rectangle(0, 0, 2, 1)
r2 = Rectangle(0, 0, 1, 2)
r3 = Rectangle(0, 0, 1, 3)
self.assertFalse(r1 < r2)
self.assertTrue(r1 < r3)
self.assertTrue(r2 < r3)
def test_split(self):
m = maxrects.MaxRects(100, 100)
m.add_rect(20, 20)
self.assertTrue(Rectangle(20, 0, 80, 100) in m._max_rects)
self.assertTrue(Rectangle(0, 20, 100, 80) in m._max_rects)
self.assertEqual(len(m._max_rects), 2)
m._split(Rectangle(20, 20, 20, 20))
self.assertEqual(len(m._max_rects), 6)
m._remove_duplicates()
self.assertEqual(len(m._max_rects), 4)
def __init__(self, x, y, width, height, rid=None, axes=None, fig=None):
assert (height >= 0 and width >= 0)
RectpackRectangle.__init__(self, x, y, width, height, rid=rid)
self.axes = axes
self.fig = fig
self.entitie = 'entitie'
self.rect = MatpRectangle((self.x, self.y),
self.width,
self.height,
alpha=1,
facecolor='none')
def test_iter(self):
m = maxrects.MaxRects(100, 100)
self.assertTrue(m.add_rect(10, 15))
self.assertTrue(m.add_rect(40, 40))
rectangles = []
for r in m:
rectangles.append(r)
self.assertTrue(Rectangle(0, 0, 10, 15) in rectangles)
self.assertTrue(Rectangle(10, 0, 40, 40) in rectangles)
self.assertEqual(len(rectangles), 2)
def test_equal(self):
r1 = Rectangle(0, 0, 1, 2)
r2 = Rectangle(0, 0, 1, 1)
r3 = Rectangle(1, 1, 1, 2)
self.assertNotEqual(r1, r3)
self.assertNotEqual(r1, r2)
self.assertNotEqual(r2, r3)
r4 = Rectangle(0, 0, 1, 2)
self.assertEqual(r1, r4)
r5 = Rectangle(1, 1, 1, 2)
self.assertEqual(r3, r5)
def test_rect_fitness(self):
m = maxrects.MaxRectsBssf(100, 100, rot=False)
self.assertEqual(m.add_rect(60, 10), Rectangle(0, 0, 60, 10))
self.assertTrue(m.fitness(30, 91) > m.fitness(30, 92))
self.assertTrue(m.fitness(38, 91) < m.fitness(30, 92))
self.assertTrue(m.fitness(38, 91) > m.fitness(40, 92))
def test_move(self):
r = Rectangle(1, 2, 2, 2)
self.assertEqual(r.bottom, 2)
self.assertEqual(r.left, 1)
r.move(10, 12)
self.assertEqual(r.bottom, 12)
self.assertEqual(r.left, 10)
self.assertEqual(r.top, 14)
self.assertEqual(r.right, 12)
self.assertEqual(r.height, 2)
self.assertEqual(r.width, 2)
self.assertEqual(r.corner_top_l, Point(10, 14))
self.assertEqual(r.corner_top_r, Point(12, 14))
self.assertEqual(r.corner_bot_l, Point(10, 12))
self.assertEqual(r.corner_bot_r, Point(12, 12))
def test_area(self):
r1 = Rectangle(0, 0, 1, 2)
r2 = Rectangle(1, 1, 2, 3)
r3 = Rectangle(1, 1, 5, 5)
self.assertEqual(r1.area(), 2)
self.assertEqual(r2.area(), 6)
def test_add_rect(self):
# Basic packing test.
m = maxrects.MaxRects(200, 100)
self.assertEqual(m.add_rect(50, 30), Rectangle(0, 0, 50, 30))
self.assertEqual(len(m._max_rects), 2)
self.assertEqual(m.add_rect(70, 200), Rectangle(0, 30, 200, 70))
self.assertEqual(len(m._max_rects), 1)
self.assertEqual(m.add_rect(20, 20), Rectangle(50, 0, 20, 20))
self.assertEqual(len(m._max_rects), 2)
self.assertEqual(m.add_rect(50, 50), None)
self.assertEqual(m.add_rect(30, 100), Rectangle(70, 0, 100, 30))
#Test with rotation disabled
m = maxrects.MaxRects(200, 50, rot=False)
self.assertEqual(m.add_rect(40, 80), None)
m = maxrects.MaxRects(200, 50, rot=True)
self.assertEqual(m.add_rect(40, 80), Rectangle(0, 0, 80, 40))
def test_remove_duplicates(self):
# Test duplicated collisions removed
m = maxrects.MaxRects(100, 100)
rect1 = Rectangle(0, 0, 60, 40)
rect2 = Rectangle(30, 20, 60, 40)
rect3 = Rectangle(35, 25, 10, 10)
rect4 = Rectangle(90, 90, 10, 10)
m._max_rects = [rect1, rect2, rect3, rect4]
m._remove_duplicates()
self.assertTrue(rect1 in m._max_rects)
self.assertTrue(rect2 in m._max_rects)
self.assertTrue(rect4 in m._max_rects)
self.assertEqual(len(m._max_rects), 3)
# Test with only one max_rect
m = maxrects.MaxRects(100, 100)
m._remove_duplicates()
self.assertEqual(len(m._max_rects), 1)
def test_rotation(self):
# Test rotation is enabled by default
s = skyline.SkylineBl(100, 10)
rect1 = s.add_rect(10, 100)
self.assertEqual(rect1, Rectangle(0, 0, 100, 10))
# Test rotation can be disabled
s = skyline.SkylineBl(100, 10, rot=False)
rect1 = s.add_rect(10, 100)
self.assertEqual(rect1, None)
def test_add_rect(self):
# Rectangle too big for surface
g = guillotine.GuillotineBssfMaxas(100, 100, merge=False)
self.assertEqual(g.add_rect(110, 3), None)
g = guillotine.GuillotineBssfMaxas(100, 100, merge=False)
self.assertEqual(g.add_rect(5, 5), Rectangle(0, 0, 5, 5))
self.assertEqual(len(g), 1)
self.assertTrue(g.add_rect(10, 10))
self.assertEqual(len(g), 2)
self.assertEqual(g.add_rect(99, 99), None)
self.assertEqual(len(g), 2)
# Test new sections created
g = guillotine.GuillotineBssfMaxas(100, 100)
self.assertEqual(len(g._sections), 1)
g.add_rect(5, 5)
self.assertEqual(len(g._sections), 2)
# Test rectangle id preserved
g = guillotine.GuillotineBssfMaxas(100, 100)
g.add_rect(5, 5, rid=88)
for r in g:
self.assertEqual(r.rid, 88)
# Test full size rectangle
g = guillotine.GuillotineBssfMaxas(300, 100)
self.assertTrue(g.add_rect(300, 100))
# Test rotations
g = guillotine.GuillotineBlsfMaxas(50, 100, rot=True)
rect = g.add_rect(100, 50)
self.assertEqual(rect, Rectangle(0, 0, 50, 100))
# Test returned coordinates
g = guillotine.GuillotineBlsfMaxas(100, 100, rot=False)
rect1 = g.add_rect(60, 40)
rect2 = g.add_rect(20, 30)
rect3 = g.add_rect(30, 40)
self.assertEqual(rect1, Rectangle(0, 0, 60, 40))
self.assertEqual(rect2, Rectangle(0, 40, 20, 30))
self.assertEqual(rect3, Rectangle(60, 0, 30, 40))
def test_reset(self):
# Test _max_rects and rectangles is initialized
m = maxrects.MaxRects(100, 200)
self.assertTrue(m.add_rect(30, 30))
self.assertTrue(m.add_rect(50, 50))
self.assertEqual(len(m), 2)
m.reset()
self.assertEqual(len(m), 0)
self.assertEqual(len(m._max_rects), 1)
self.assertEqual(len(m.rectangles), 0)
self.assertEqual(m._max_rects[0], Rectangle(0, 0, 100, 200))
def test_split_vertical(self):
# Normal split
g = guillotine.Guillotine(100, 100)
section = g._sections[0]
g._sections = []
g._split_vertical(section, 50, 50)
self.assertTrue(Rectangle(50, 0, 50, 100) in g._sections)
self.assertTrue(Rectangle(0, 50, 50, 50) in g._sections)
self.assertEqual(len(g._sections), 2)
# Full width split
g = guillotine.Guillotine(100, 100)
section = g._sections[0]
g._sections = []
g._split_vertical(section, 100, 50)
self.assertTrue(Rectangle(0, 50, 100, 50) in g._sections)
self.assertEqual(len(g._sections), 1)
# Full Height split
g = guillotine.Guillotine(100, 100)
section = g._sections[0]
g._sections = []
g._split_vertical(section, 50, 100)
self.assertTrue(Rectangle(50, 0, 50, 100) in g._sections)
self.assertEqual(len(g._sections), 1)
# Full section split
g = guillotine.Guillotine(100, 100)
section = g._sections[0]
g._sections = []
g._split_vertical(section, 100, 100)
self.assertEqual(len(g._sections), 0)
def test_skyline4(self):
"""
+---------------------+-----+
| 4 | 5 |
| | |
+----+----------------------+
| | | |
| | | |
| | | |
| | w1 | |
| 1 | | 3 |
| | | |
| | | |
| | | |
| +----------------+ |
| | | |
| | 2 | |
| | | |
+----+----------------+-----+
"""
s = skyline.SkylineMwflWm(100, 100, rot=False)
rect1 = s.add_rect(20, 80)
rect2 = s.add_rect(60, 20)
rect3 = s.add_rect(20, 80)
rect4 = s.add_rect(80, 20)
w1 = s.add_rect(60, 50)
rect5 = s.add_rect(20, 20)
self.assertEqual(rect1, Rectangle(0, 0, 20, 80))
self.assertEqual(rect2, Rectangle(20, 0, 60, 20))
self.assertEqual(rect3, Rectangle(80, 0, 20, 80))
self.assertEqual(rect4, Rectangle(0, 80, 80, 20))
self.assertEqual(rect5, Rectangle(80, 80, 20, 20))
self.assertEqual(w1, Rectangle(20, 20, 60, 50))
def test_getitem(self):
"""Test __getitem__ returns requested element or slice"""
g = guillotine.GuillotineBafSas(100, 100)
g.add_rect(10, 10)
g.add_rect(5, 5)
g.add_rect(1, 1)
self.assertEqual(g[0], Rectangle(0, 0, 10, 10))
self.assertEqual(g[1], Rectangle(0, 10, 5, 5))
self.assertEqual(g[2], Rectangle(5, 10, 1, 1))
self.assertEqual(g[-1], Rectangle(5, 10, 1, 1))
self.assertEqual(g[-2], Rectangle(0, 10, 5, 5))
self.assertEqual(g[1:],
[Rectangle(0, 10, 5, 5), Rectangle(5, 10, 1, 1)])
self.assertEqual(g[0:2],
[Rectangle(0, 0, 10, 10), Rectangle(0, 10, 5, 5)])
def test_initialization(self):
r = Rectangle(1, 2, 3, 4)
self.assertEqual(r.left, 1)
self.assertEqual(r.bottom, 2)
self.assertEqual(r.right, 4)
self.assertEqual(r.top, 6)
self.assertEqual(r.width, 3)
self.assertEqual(r.height, 4)
self.assertEqual(r.corner_top_l, Point(1, 6))
self.assertEqual(r.corner_top_r, Point(4, 6))
self.assertEqual(r.corner_bot_l, Point(1, 2))
self.assertEqual(r.corner_bot_r, Point(4, 2))
def test_iter(self):
# Iterate through rectangles
w = waste.WasteManager()
w.add_waste(30, 40, 50, 50)
w.add_waste(5, 5, 20, 20)
w.add_waste(0, 100, 100, 100)
w.add_rect(50, 50)
for r in w:
self.assertEqual(r, Rectangle(30, 40, 50, 50))
self.assertEqual(len(w), 1)
