import collections
import itertools
import operator
import heapq
import copy
from .pack_algo import PackingAlgorithm
from .geometry import Point as P
from .geometry import HSegment, Rectangle
from .waste import WasteManager
class Skyline(PackingAlgorithm):
""" Class implementing Skyline algorithm as described by
Jukka Jylanki - A Thousand Ways to Pack the Bin (February 27, 2010)
_skyline: stores all the segments at the top of the skyline.
_waste: Handles all wasted sections.
"""
def __init__(self, width, height, rot=True, *args, **kwargs):
"""
_skyline is the list used to store all the skyline segments, each
one is a list with the format [x, y, width] where x is the x
coordinate of the left most point of the segment, y the y coordinate
of the segment, and width the length of the segment. The initial
segment is allways [0, 0, surface_width]
Arguments:
width (int, float):
height (int, float):
rot (bool): Enable or disable rectangle rotation
"""
self._waste_management = False
self._waste = WasteManager(rot=rot)
super(Skyline, self).__init__(width, height, rot, merge=False, *args, **kwargs)
def _placement_points_generator(self, skyline, width):
"""Returns a generator for the x coordinates of all the placement
points on the skyline for a given rectangle.
WARNING: In some cases could be duplicated points, but it is faster
to compute them twice than to remove them.
Arguments:
skyline (list): Skyline HSegment list
width (int, float): Rectangle width
Returns:
generator
"""
skyline_r = skyline[-1].right
skyline_l = skyline[0].left
# Placements using skyline segment left point
ppointsl = (s.left for s in skyline if s.left+width <= skyline_r)
# Placements using skyline segment right point
ppointsr = (s.right-width for s in skyline if s.right-width >= skyline_l)
# Merge positions
return heapq.merge(ppointsl, ppointsr)
def _generate_placements(self, width, height):
"""
Generate a list with
Arguments:
skyline (list): SkylineHSegment list
width (number):
Returns:
tuple (Rectangle, fitness):
Rectangle: Rectangle in valid position
left_skyline: Index for the skyline under the rectangle left edge.
right_skyline: Index for the skyline under the rectangle right edte.
"""
skyline = self._skyline
points = collections.deque()
left_index = right_index = 0 # Left and right side skyline index
support_height = skyline[0].top
support_index = 0
placements = self._placement_points_generator(skyline, width)
for p in placements:
# If Rectangle's right side changed segment, find new support
if p+width > skyline[right_index].right:
for right_index in range(right_index+1, len(skyline)):
if skyline[right_index].top >= support_height:
support_index = right_index
support_height = skyline[right_index].top
if p+width <= skyline[right_index].right:
break
# If left side changed segment.
if p >= skyline[left_index].right:
left_index +=1
# Find new support if the previous one was shifted out.
if support_index < left_index:
support_index = left_index
support_height = skyline[left_index].top
for i in range(left_index, right_index+1):
if skyline[i].top >= support_height:
support_index = i
support_height = skyline[i].top
# Add point if there is enought room at the top
if support_height+height <= self.height:
points.append((Rectangle(p, support_height, width, height),\
left_index, right_index))
return points
def _merge_skyline(self, skylineq, segment):
"""
Arguments:
skylineq (collections.deque):
segment (HSegment):
"""
if len(skylineq) == 0:
skylineq.append(segment)
return
if skylineq[-1].top == segment.top:
s = skylineq[-1]
skylineq[-1] = HSegment(s.start, s.length+segment.length)
else:
skylineq.append(segment)
def _add_skyline(self, rect):
"""
Arguments:
seg (Rectangle):
"""
skylineq = collections.deque([]) # Skyline after adding new one
for sky in self._skyline:
if sky.right <= rect.left or sky.left >= rect.right:
self._merge_skyline(skylineq, sky)
continue
if sky.left < rect.left and sky.right > rect.left:
# Skyline section partially under segment left
self._merge_skyline(skylineq,
HSegment(sky.start, rect.left-sky.left))
sky = HSegment(P(rect.left, sky.top), sky.right-rect.left)
if sky.left < rect.right:
if sky.left == rect.left:
self._merge_skyline(skylineq,
HSegment(P(rect.left, rect.top), rect.width))
# Skyline section partially under segment right
if sky.right > rect.right:
self._merge_skyline(skylineq,
HSegment(P(rect.right, sky.top), sky.right-rect.right))
sky = HSegment(sky.start, rect.right-sky.left)
if sky.left >= rect.left and sky.right <= rect.right:
# Skyline section fully under segment, account for wasted space
if self._waste_management and sky.top < rect.bottom:
self._waste.add_waste(sky.left, sky.top,
sky.length, rect.bottom - sky.top)
else:
# Segment
self._merge_skyline(skylineq, sky)
# Aaaaand ..... Done
self._skyline = list(skylineq)
def _rect_fitness(self, rect, left_index, right_index):
return rect.top
def _select_position(self, width, height):
"""
Search for the placement with the bes fitness for the rectangle.
Returns:
tuple (Rectangle, fitness) - Rectangle placed in the fittest position
None - Rectangle couldn't be placed
"""
positions = self._generate_placements(width, height)
if self.rot and width != height:
positions += self._generate_placements(height, width)
if not positions:
return None, None
return min(((p[0], self._rect_fitness(*p))for p in positions),
key=operator.itemgetter(1))
def fitness(self, width, height):
"""Search for the best fitness
"""
assert(width > 0 and height >0)
if width > max(self.width, self.height) or\
height > max(self.height, self.width):
return None
# If there is room in wasted space, FREE PACKING!!
if self._waste_management:
if self._waste.fitness(width, height) is not None:
return 0
# Get best fitness segment, for normal rectangle, and for
# rotated rectangle if rotation is enabled.
rect, fitness = self._select_position(width, height)
return fitness
def add_rect(self, width, height, rid=None):
"""
Add new rectangle
"""
assert(width > 0 and height > 0)
if width > max(self.width, self.height) or\
height > max(self.height, self.width):
return None
rect = None
# If Waste managment is enabled, first try to place the rectangle there
if self._waste_management:
rect = self._waste.add_rect(width, height, rid)
# Get best possible rectangle position
if not rect:
rect, _ = self._select_position(width, height)
if rect:
self._add_skyline(rect)
if rect is None:
return None
# Store rectangle, and recalculate skyline
rect.rid = rid
self.rectangles.append(rect)
return rect
def reset(self):
super(Skyline, self).reset()
self._skyline = [HSegment(P(0, 0), self.width)]
self._waste.reset()
class SkylineWMixin(Skyline):
"""Waste managment mixin"""
def __init__(self, width, height, *args, **kwargs):
super(SkylineWMixin, self).__init__(width, height, *args, **kwargs)
self._waste_management = True
class SkylineMwf(Skyline):
"""Implements Min Waste fit heuristic, minimizing the area wasted under the
rectangle.
"""
def _rect_fitness(self, rect, left_index, right_index):
waste = 0
for seg in self._skyline[left_index:right_index+1]:
waste +=\
(min(rect.right, seg.right)-max(rect.left, seg.left)) *\
(rect.bottom-seg.top)
return waste
def _rect_fitnes2s(self, rect, left_index, right_index):
waste = ((min(rect.right, seg.right)-max(rect.left, seg.left)) for seg in self._skyline[left_index:right_index+1])
return sum(waste)
class SkylineMwfl(Skyline):
"""Implements Min Waste fit with low profile heuritic, minimizing the area
wasted below the rectangle, at the same time it tries to keep the height
minimal.
"""
def _rect_fitness(self, rect, left_index, right_index):
waste = 0
for seg in self._skyline[left_index:right_index+1]:
waste +=\
(min(rect.right, seg.right)-max(rect.left, seg.left)) *\
(rect.bottom-seg.top)
return waste*self.width*self.height+rect.top
class SkylineBl(Skyline):
"""Implements Bottom Left heuristic, the best fit option is that which
results in which the top side of the rectangle lies at the bottom-most
position.
"""
def _rect_fitness(self, rect, left_index, right_index):
return rect.top
class SkylineBlWm(SkylineBl, SkylineWMixin):
pass
class SkylineMwfWm(SkylineMwf, SkylineWMixin):
pass
class SkylineMwflWm(SkylineMwfl, SkylineWMixin):
pass